Interleaver device and method for interleaving a data set

ABSTRACT

An interleaver device configured to interleave a data set, comprising an interleaver driver, a processing unit including a data processor configured to operate as an interleaver under the control of the interleaver driver, a data input device configured to input the data set to be interleaved, and a data output device configured to output an interleaved data set. The interleaver driver includes a mapping processor configured to calculate a set of bijective elementary functions (φ n ) and to supply a mapping of the interleaver to the data processor. The interleaver driver also includes an interleaver definition generator configured to supply an interleaver definition to the mapping processor. The interleaver definition includes a compound function (φ k o . . . oφ 1 ) of at least one bijective elementary function drawn from the set of bijective elementary functions (φ n ).

FIELD OF INVENTION

The invention concerns an interleaver device for interleaving a data set comprising a data processor for running an interleaver under the control of driving means and an input means for inputting the data set to be interleaved and output means for outputting the interleaved data set.

BACKGROUND OF INVENTION

Such interleaver devices are specially useful in mobile telephones.

An interleaver is usually applied on informations transmitted on a radio channel between two radio stations.

In other technical fields, interleavers are also used for instance on data stored on a magnetic tape or a laser disk.

Turbo decoders have proved to offer near Shannon limit error protection in the case of white additive gaussian noise. One key feature of the Turbo encoder is an interleaver.

Interleaving data with a depth of N consists in:

writing N consecutive symbols of data into a buffer of size of N symbols, i^(th) written symbol is written at position (i−1), and then

read them in another order given by some permutation I of {0, . . . , N−1}. i^(th) read symbol is read from position I(i−1).

In other words if i is the original position of a symbol in an input block, then I⁻¹(i) is its position in the output block, where I⁻¹ denotes the inverse permutation of I.

Deinterleaving data with a depth of N consists in:

writing N consecutive symbols of data into a buffer of size of N symbols, i^(th) written symbol is written at position I(i−1), and

then and then read them in another order given by some permutation I on {0, . . . , N−1}. i^(th) read symbol is read from position i−1.

To implement the interleaver and the deinterleaver, function is needed that provides the mapping I. With some simple permutation I, this mapping can be computed by a simple analytical formula that can be quickly evaluated on any known per se processing means. For instance if the interleaver is a rectangular interleaver with L lines and C columns, we have:

N=L·C

∀i∈{0, . . . , N−1}I ⁻¹(i)=(i div C)+(i mod C)·L  (1)

In this formula (x div y) stands for the quotient of x divided by y in an Euclidian division and (x mod y) stands for the remainder in the same division.

The way this formula is to be understood is quite simple: a rectangular interleaver consists of an array of L lines and C columns. The input data is written along the lines and read along the column.

If l is line number (from 0 to L−1) and c is a column number (from 0 to C−1) of some written symbol then writing along the line comes to:

c=i mod C  (2)

l=i div C  (3)

that is to say:

i=l·C+c  (4)

l and c are the co-ordinate of the (i+1)^(th) written symbol.

Reading along the columns comes to:

I ⁻¹(i)=l+c·L  (5)

Note that as a matter of fact, equations (4) and (5) are similar when column and line roles are inverted. By substituting equations (3) and (2) in equation (5), we get equation (1) that shows that the I mapping can be obtained by simple arithmetic computations in the case of a rectangular interleaver.

However interleavers so simple as the rectangular interleaver do not always fit the needs of a forward error coding technique. In particular, in the case of the turbo encoding, the rectangular interleaver shows very poor performance. The interleaver to be used in the turbo encoder must be more random than the regular rectangular interleaver, and however not completely random as it must still keep some good properties of spacing interleaved symbols.

The simplest way to implement that kind of interleaver is to use a table where the i^(th) entry in the table is the value of I(i−1). The size of the table is directly derived from N, that is to say that at least s(N) bits are needed to implement the table where:

 s(x)=x·┌log₂(x)┐  (6)

log₂(x) denotes the logarithm in base two of x, and ┌x┐ denotes the ceiling of x, that is to say the least integer not less than x. When N grows bigger, then the amount of memory needed to store the table also grows bigger.

SUMMARY OF INVENTION

The aim of the invention is to provide an interleaver device which can run with very little memory to store the definition of the interleaver, even if the interleaver definition is very complex.

To this end, the invention relates to an interleaver device as defined in claim 1.

According to particular embodiments, the interleaver device may include one or more of the features defined in subclaims.

The invention proposes a method to build interleavers that are not so regular as the plain rectangular interleaver and nevertheless use far less memory than a completely tabulated interleaver.

In the case of a mobile telephone, due to real time constraint, it might be necessary to tabulate the interleaver of the invention to be able to use it, since processing the values might take too much time. However the definition can be very concise, thus holding little space in ROM. The interleaver table can held in RAM and computed off-line, during connection establishment. After call completion, the RAM can be reused for another purpose. Thus, even if the interleaver needs to be tabulated into RAM for effective use, this is all the same favourable, because the RAM can be used for something else when the call type does not need the interleaver.

Another advantage of having a concise definition from which a very large interleaver can be generated, is that a great variety of interleavers can be defined in the ROM memory, and only one of them selected at connection time.

In a particular embodiment, the interleaver definition could be transmitted over the air, as a parameter of the connection. The interleaver definition would have to follow the mobile telephone if during a hand over of the site where the interleaving is performed in the network is changed. Therefore, the next site would need to compute or select the table fast if enough during the hand over preparation time.

BRIEF DESCRIPTION OF THE DRAWINGS

The invention will be understood more cleady on reading the following description, given solely by way of example and made with reference to the drawings, in which:

FIG. 1 is a block diagram of an interleaver device according to the invention;

FIG. 2 is a flow-chart showing a Mod-threshold term splitting algorithm;

FIG. 3 is an illustration of a term splitting function applied on a data set;

FIG. 4 is an illustration of a Div-mod factor split function applied on a data set;

FIG. 5 is an illustration of a mod-mod factor split function applied on a data set;

FIG. 6 is an illustration of a rectangular interleaver applied to a data set;

FIG. 7 is an illustration of a truncated rectangular interleaver applied to a data set; and

FIG. 8 is an illustration of a puncturing of an interleaver.

DETAILED DESCRIPTION

The interleaver according to the invention can be implemented on any data processing means adapted to run under the driving of a software using the splitting of the interleaver as defined hereafter.

For example, the interleaver can be implemented in a mobile telephone.

Generally, and as shown on FIG. 1, the interleaver device includes a processing unit 10. It also includes means 12 for inputting a data set to be interleaved and means 14 for outputting the interleaved data.

The processing unit 10 includes a data processor 16 connected to the inputting means 12 for receiving a data set to be interleaved. It is also connected to outputting means 14 for supplying the interleaved data.

The data processor 16 is adapted for running an interleaved I⁻¹, the mapping of which is supplied by driving means 18. The driving means 18 comprise mapping processing means 20 which are adapted to compute a mapping of the interleaver from a set of elementary bijective functions φ_(n) which can be derived from a Read only memory 22. The computation is performed, according to an interleaver definition I⁻¹ received from interfeaver definition means 24.

In the present embodiment, the elementary functions are stored in the Read only memory 22. Typically these elementary functions may be not completely defined in ROM 22, and zero one or more additional parameters may need to be supplied for them to be operated on their argument.

Interleaver definition means 24, typically consisting of a memory, are provided to supply the definition of the interleaver I⁻¹ to mapping processing means 20. This definition is based on the elementary functions stored in memory 22. In particular, the interleaver I⁻¹ is defined as a compound of the elementary functions φ_(n) stored in ROM 22, along with the suitable parameters if any. The mapping processing means 20 drive the data processor 10 for it to interleave data according to the mapping which is computed by the mapping processing means 20. This mapping is determined by performing each of the functions φ_(n) used to define the interleaver compounded according to the interleaver definition I⁻¹.

Typically the mapping processing means 20 compute the mapping from the definitions from ROM 22 and interleaver definition means 24 only once during connection establishment, and then keep it in a look-up table. In another embodiment, the mapping processing means 24 compute from the definition of I⁻¹ the image I⁻¹(i) of the position i of a data symbol to be interleaved on the fly at every symbol.

The implementation of the interleaver can be easily carried out by a man skilled in the art in view of the following explanations.

The definition of interleavers by the inventive method is recursive. The interleaver is defined by a permutation I⁻¹ on the set {0, 1, . . . , N−1} of the initial position indexes of the data to be interleaved. This set of position in-dexes, on which operates the interleaver I is split into a sum or a product of two smaller sets. Each of these two smaller sets can be then:

either permuted by the underlying index permutation of a smaller interleaver,

either split itself again in a sum or a product of two other smaller sets, or

merged with a smaller set that was produced during a previous split of set.

The invention allows the use of interleavers external to the invention in place of the smaller interleavers. These external interleavers can be tabulated, or computed by a processing method different from that of the invention.

In the description, the following notations are used.

Finite Elementary Set of Integer

For any non null positive integer x, denotes the set:

={i/i integer and 0≦i≦x−1}

Ellipsis Notation

The ellipsis ( . . . ) notation is used in the middle of a sequence instead of the full sequence. This notation does not make any assumption on the number of literals in the formal sequence using it. These convention are quite obvious and usual. Below, some instances are given: A₁ × … × A_(p)  Shall  be  interpreted  just  as  A₁  if  p = 1 A₁ ⊕ … ⊕ A_(p)  shall  be  interpreted  just  as  A₁  if  p = 1 A₁ ⊕ … ⊕ A_(p)  shall  be  interpreted  just  as  the  empty  set  ⌀  if  p = 0 {x, x + 1, …  , y − 1, y}  where  x  and  y  are  integers, shall  be  interpreted  just  as  {x}  if  x = y {x, x + 1, …  , y − 1, y}  where  x  and  y  are  integers, shall  be  interpreted  the  empty  set  ⌀  if  x > y

Product of Sets

If A and B are two sets, then their product A×B is the set of couples (a,b) such that a is in A and b in B. In other words:

A×B={(a,b)/a∈A and b∈B}

The concept can be generalised to any finite number of sets:

A ₁ x . . . xA _(p)={(a ₁ , . . . , a _(p))/∀i a _(l) ∈A _(l)}

Furthermore, for the sake of simplicity, A×(B×C), or (A×B)×C will just be denoted A×B×C, since there are obvious bijections between these three sets, that is to say there is little difference between ((a,b),c), (a,(b,c)) and (a,b,c).

One property of the product of sets is that if A₁, A₂, . . . A_(p) are finite sets and their respective numbers of elements are denoted |A₁|, |A₂|, . . . |A_(p)|, then A₁x . . . xA_(p) is also finite, and its number of elements |A₁x . . . xA_(p)| is such that: ${{A_{1} \times \ldots \times A_{p}}} = {\prod\limits_{i = 1}^{i = p}\quad {A_{i}}}$

Union od Sets

The union (noted ∪) of two sets is the set of elements that are in at least one of these two sets. That is to say A∪B {x/x∈A or x∈B}.

Disjoint Union of Stes (Also Called Here Sun of Stes)

If A and B are two sets, then their sum AB is the set of couples (t,x) such that t is equal to 1 or 2 respectively when x is A or in B.

Consequently, AB ({1}×A)∪({2}×B).

1 and 2 are the usual integers and are used to distinguish the elements of A and of B in the union, so that the union is “disjoint”.

The concept can be generalised to any finite number of sets:

A ₁ . . . A _(p)=({1}×A ₁)∪ . . . ∪({p}×A _(p))

Where 1, 2, . . . p are the usual whole numbers.

In the following for (t,x) in A₁ . . . A_(p), t is called the tag and x is called the value.

Furthermore, for the sake of simplicity, A(BC), and (AB)C will just be denoted ABC, since there are obvious bijections between these three sets, that is to say there is little difference between the tag sets {1, (2,1), (2,2)}, {1, (1,1), (1,2)}, and {1,2,3}. The main use of the tag is its ability to distinguish the elements according to their set of origin.

Note that the disjoint union is generally defined in literature such that AB=BA, that is to say there is no underlying order on the set of tags, and therefore neither are the terms ordered. However the definition is slightly modified, because this property is not desirable for this application. In the following, the expression “sum of sets” instead of “disjoint union of sets” will be used.

Finally, one property of the disjoint union of sets is that if A₁, A₂, . . . A_(p) are finite sets and their respective number of elements are denoted |A₁|, |A₂|, . . . |A_(p)|, then A₁ . . . A_(p) is also finite, and its number of elements |A₁ . . . A_(p)| is such that: ${{A_{1} \oplus \ldots \oplus A_{p}}} = {\sum\limits_{i = 1}^{i = p}\quad {A_{i}}}$

Distribution of Product of Sets Over Sun of Sets.

In the following it is considered that:

A×(BC) is the same as (A×B)(A×C)

As a matter of fact, there is an obvious bijection mapping the element (a,(t,v)) of A×(BC) on the element (t,(a,v)) of (A×B)(A×C). This bijection just consists in placing the tag in first position.

Similarly it is considered that (AB)×C is the same as (A×C)(B×C).

The interleaver I is built as follows. It enables a concise definition of the interleaver using several bijective elementary functions.

The general idea to is to build the bijection I⁻¹→ as the compound of several bijections φ₁, φ₂, . . . , φ_(k). That is to say I⁻¹=φ_(k)° . . . °φ₂°φ₁

This way we have: ∀n ∈ {1, …  k}  ϕ_(n)  S^((n − 1)) → S^((n)) With  S⁽⁰⁾ = N  and  S^((k)) = N.

This way we have: I⁻¹:NN $S^{(0)}\quad \underset{\rightarrow}{\phi_{1}}\quad S^{(1)}\quad \underset{\rightarrow}{\phi_{2}}\quad \ldots \quad \underset{\rightarrow}{\phi_{k}}\quad S^{(k)}$ x  ↦  ϕ₁  (x)  ↦  ↦  I⁻¹  (x) = ϕ_(k)  (ϕ_(k − 1)  (…  ϕ₂  (ϕ₁  (x))…))

and I⁻¹ is so built as a compound or sequence of k simpler steps, each step consisting of a bijective function φ_(n).

One more aspect is that each intermediate set S^((n)) can be defined as a sum of simpler sets T_(I) ^((n)) that are products of sets of the form: ∀n ∈ {1, …  , k}  S^((n)) = T₁^((n)) ⊕ … ⊕ T_(q_(n))^((n))  where:∀n ∈ {1, …  , k}∀i ∈ {1, …  , q_(n)}  T_(i)^((n)) = N_(i, 1)^((n)) × N_(i, 2)^((n)) × … × N_(i, p_(i, n))^((n))

and with (for all the φ_(n) are bijective), all the intermediate sets S^((n)) having N elements: ${\forall{n \in \left\{ {0,\ldots \quad,k} \right\}}},{{S^{(n)}} = {{\sum\limits_{i = 1}^{i = q_{n}}\quad \left( {\prod\limits_{j = 1}^{j = p_{i,n}}\quad N_{i,j}^{(n)}} \right)} = N}}$

and also q₀=1 p_(1,0)=1, N_(1,1) ⁽⁰⁾=N, q_(k)=1, p_(1,k)=1 and N_(1,1) ^((k))=N, because

Note that for the present application, it is needed that each φ_(n) be easily implementable by an algorithm that can be run on existing processing means.

Several types of φ_(n) elementary functions are defined. The different φ_(n) elementary functions form a set of elementary functions which are stored in memory 22, so that their algorithm can be run by the mapping processing means 20 according to the interleaver definition I⁻¹.

Here is an introductory list of the functions that will be presented in more details later:

A. Functions to simplify the definitions of the other functions by putting in first position the terms or factors on which the next function is to operate:

Term permutation

Factor permutation

B. Functions to decompose S^((n−1)) into an S^((n)) with more terms or factors:

Elementary term split

Elementary factor split

C. Functions ensuring the equivalence between A×(BC) and (A×B)(A×C)

Factorisation

Distribution

D. Function to interleave a part of S^((n−1))

Elementary interleaving: embedding of an interleaver external to the invention

Affine-mod: a linear relation followed by a modulus, and operating on a term of S^((n−1)) as if it was a vector space whose dimension is the number of factors in this term,

E. Functions to simplify S^((n−1)) into an S^((n)) with fewer terms or factors:

Elementary factor merge

Elementary term merge

The different functions are as follows.

Term Permutation φ_(n)

In that case:

q_(n)=q_(n−1)

σ a permutation of {1, . . . , q_(n)}, and

∀i∈{1, . . . , q_(n)}T_(σ(i)) ^((n))=T_(i) ^((n−1))

φ_(n) is defined as: $\begin{matrix} {\phi_{n}\text{:}} & S^{({n - 1})} & \rightarrow & S^{(n)} \\ \quad & \left( {t,v} \right) & \mapsto & \left( {{\sigma \quad (t)},v} \right) \end{matrix}$

In the definition above t is the tag of (t,v), and v the value.

Example: S^((n − 1)) = 2 × 3 ⊕ 4 × 5 ⊕ 3 S^((n)) = 3 ⊕ 4 × 5 ⊕ 2 × 3 σ = (3, 2, 1)

And for instance we have the following mappings: $\begin{matrix} {\phi_{n}\text{:}} & \left( {1,\left( {1,1} \right)} \right) & \mapsto & \left( {3,\left( {1,1} \right)} \right) \\ \quad & \left( {3,(2)} \right) & \mapsto & \left( {1,(2)} \right) \\ \quad & \left( {2,\left( {3,0} \right)} \right) & \mapsto & \left( {2,\left( {3,0} \right)} \right) \end{matrix}$

Factor Permutation φ_(n)

The factor permutation φ_(n) function permutes the factors in the product constituting the first term of S^((n−1)). In fact the same principle could be used to permutes the factors of any term, but this is not needed for the definition thanks to the term permutation function defined above.

In that case we have:

q_(n)=q_(n−1)

p_(1,n)=p_(1,n−1)

σ a permutation of {1, . . . , p_(1,n−1)}

∀i∈{2, . . . , q_(n)}=T_(i) ^((n−1))

∀j∈{1, . . . , p_(1,n−1}N) _(1,j) ^((n))=N_(1,σ(j)) ^((n−1))

φ_(n) is defined as: ${\begin{matrix} {\phi_{n}\text{:}} & S^{({n - 1})} & \rightarrow & S^{(n)} \\ \quad & {x = \left( {t,\left( {x_{1},{x_{2}\quad \ldots \quad x_{p_{t,{n - 1}}}}} \right)} \right)} & \mapsto & \left\{ \begin{matrix} \left( {1,\left( {x_{\sigma \quad {(1)}},{x_{\sigma \quad {(2)}}\quad \ldots \quad x_{\sigma \quad {(p_{1,{n - 1}})}}}} \right)} \right) \\ {x\quad {otherwise}} \end{matrix} \right. \end{matrix}\quad {if}\quad t} = 1$

Example: S^((n − 1)) = 2 × 3 × 4 ⊕ 3 S^((n − 1)) = 3 × 2 × 4 ⊕ 3

σ=(2,1,3)

And for instance we have the following mappings: $\begin{matrix} {\phi_{n}\text{:}} & \left( {1,\left( {1,2,3} \right)} \right) & \mapsto & \left( {1,\left( {2,1,3} \right)} \right) \\ \quad & \left( {2,(2)} \right) & \mapsto & \left( {2,(2)} \right) \\ \quad & \left( {1,\left( {0,1,2} \right)} \right) & \mapsto & \left( {1,\left( {1,0,2} \right)} \right) \end{matrix}$

For the term or factor permutation, φ_(n) is made at null processing cost. The only added value of φ_(n) is that it makes simpler the definitions that will follow by alleviating the notation. The following definitions are applicable to any terms or factors in a sum or product of sets, respectively, instead, thanks to the factor permutation φ_(n) we can without any loss of generality make them only for the first or the first and some subsequent terms or factors according to the case.

In consequence the permutation a is typically the compound of zero, one or two transpositions. A transposition is a permutation that swaps two elements of a set, and let the other unchanged. Thus such a permutation σ puts in the first position the terms or factors on which the next function φ_(n) is to operate. In other words the term or factor permutation function specifies on which term(s) or factor(s) is operating the next function in the φ_(k)° . . . °φ₂°φ₁ compound.

Elementary Term Split φ_(n)

The elementary term split function φ_(n) is splitting the first factor in the first term of S^((n−1)) into a sum of two sets. In fact, the same principle could be used to split any factor of any term, but this is not needed for the definition, thanks to the term and factor permutation functions defined above. An example is given on FIG. 3.

S^((n)) is such that from S^((n−1)) to S^((n)), nothing is changed except the first factor of the first term T₁ ^((n−1)) that is split by a bijection f into the sum of of and on which are then distributed the subsequent factors, if any, of the first term of S^((n−1)).

In that case:

q_(n)=q_(n−1)+1, i.e. one more term

∀i∈{2, . . . , q_(n−1)}T_(i+1) ^((n))=T_(i) ^((n−1)), i.e. the subsequent terms unchanged

A and B are two positive and non null integers, and N_(1,1) ^((n−1))=A+B, N_(1,1) ^((n))=A and N_(2,1) ^((n))=B

p_(1,n)=p_(2,n)=p_(1,n−1) and ∀j∈{2, . . . , p_(1,n−1)}N_(1,j) ^((n))=N_(2,j) ^((n))=N_(1,j) ^((n−1)) $\begin{matrix} {a\quad {bijection}} & {f\text{:}} & {A + B} & \rightarrow & {A \oplus B} \\ \quad & \quad & x & \mapsto & \left( {{t_{f}\quad (x)},{v_{f}\quad (x)}} \right) \end{matrix}$

where t_(f)(x) and v_(f)(x) respectively denote the tag and the value of f(x) in

Note that the conditions of 3^(rd) and 4^(th) bullets are such that: T₁^((n − 1)) = A + B × T^(′) T₁^((n)) = A × T^(′) T₂^((n)) = B × T^(′) And  T^(′) = N_(1, 2)^((n − 1)) × … × N_(1, p_(1, n − 1))^((n − 1))

φ_(n) is built as: $\begin{matrix} {\phi_{n}\text{:}} & S^{({n - 1})} & \rightarrow & S^{(n)} \\ \quad & x & \mapsto & \left\{ \begin{matrix} \left( {{t_{f}\quad \left( x_{1} \right)},\left( {{v_{f}\quad \left( x_{1} \right)},{x_{2}\quad \ldots \quad x_{p_{1,{n - 1}}}}} \right)} \right) & {{{if}\quad t} = 1} \\ \left( {{t + 1},v} \right) & {otherwise} \end{matrix} \right. \end{matrix}$ with x = (t, v) and v = (x₁, x₂  …  x_(p_(t, n − 1)))

The f bijections used by the elementary term split function can be defined as follows. f:  A + B → A ⊕ B  main  functions

There are many possible functions that all are computable on any current processor.

As an example of f, the mod-threshold term split function will be described hereafter:

In this function, the modulus of an element x of by some constant C is computed. Then it is compared to a threshold T. According to the result of this comparison, it is decided to map x either to or to . Constants C and T are such that:

0<T<C

In order to understand more easily how the mod-threshold function works, a simplified algorithm will be first presented. The simplified algorithm cannot make the mapping in a random way, but only in a sequential way, that is to say it can map element x, only after having mapped elements 0, 1, . . . , x−1 before.

In the simplified algorithm there are two counters nA and nB that hold the number of elements that have already been respectively mapped to and . n_(A): = 0; n_(B): = 0; for  x: = 0  to  A + B − 1  do   begin   if  (n_(A) = A)  then   begin   remark  A  is  full, then  map  x  to  B   map  x  to  (2, n_(B));   n_(B): = n_(B) + 1;   end   else  if  (n_(B) = B)  then   begin   remark  B  is  full, then  map  x  to  A     map  x  to  (1, n_(A))   n_(A): = n_(A) + 1;   end   else   begin   remark  neither  A  or  B  are  yet  full, then  map  x  accord- ing  to  threshold  of  modulus   c: = x  mod  C;   if  c < T  then   begin   map  x  to  (1, n_(A));   n_(A): = n_(A) + 1;   end   else   begin   map  x  to  (2, n_(B));   n_(B): = n_(B) + 1;   end   end end    

Now, an algorithm that can work with random values of x in input (x not given in a sequential way) is presented. Three constants x_(M), v_(M) and t_(M) are derived from A, B, C and T according to the following definitions and formulas:

x_(M) is the greatest x while neither nor are yet full in the simplified algorithm above.

t_(M) is the tag of the set ( or ) not yet full after x_(M) has been reached by x in the simplified algorithm

v_(M) is the greatest value of the set not yet full while both sets are not yet full in the simplified algorithm.

x_(M), t_(M) and v_(M) can be alternatively defined by the following formulas: $x_{M}\overset{\Delta}{=}{\max \left\{ {{x \in {{A + B}\text{/}\left( \begin{matrix} {{{l \cdot T} + c} < A} & {{{if}\quad c} < T} & \quad \\ {and} & \quad & {{,{{{where}\quad l}\overset{\Delta}{=}{x\quad {div}\quad C}},{{{and}\quad c}\overset{\Delta}{=}{x\quad {mod}\quad C}}}\quad} \\ {{{l \cdot \left( {C - T} \right)} + c - T} < B} & {otherwise} & \quad \end{matrix} \right\} t_{M}}}\overset{\Delta}{=}\left( {{\begin{matrix} 1 & {{{if}\quad \left( {\left( {x_{M} + 1} \right)\quad {mod}\quad C} \right)} \geq T} \\ 2 & {otherwise} \end{matrix}{if}\quad t_{M}} = {{1\quad {then}\quad v_{M}}\overset{\Delta}{=}{\max \left\{ {{v\text{/}{\exists{x \leq x_{M}}}},\left( {\left. \begin{matrix} {\text{/}\overset{\Delta}{=}{x\quad {div}\quad C}} \\ {and} \\ {c\overset{\Delta}{=}{x\quad {mod}\quad C}} \end{matrix}\Rightarrow{\left( \begin{matrix} {c < T} \\ {and} \\ {v = {{l \cdot T} + c}} \end{matrix} \right\} {if}\quad t_{M}} \right. = {{2\quad {then}\quad v_{M}}\overset{\Delta}{=}{\max \left\{ {{v\text{/}{\exists{x \leq x_{M}}}},\left( \begin{matrix} {\text{/}\overset{\Delta}{=}{x\quad {div}\quad C}} \\ {and} \\ {c\overset{\Delta}{=}{x\quad {mod}\quad C}} \end{matrix}\Rightarrow\left( \begin{matrix} {c \geq T} \\ {and} \\ {v = {{l \cdot \left( {C - T} \right)} + c - T}} \end{matrix} \right. \right.} \right\}}}} \right.} \right.}}} \right.} \right.}$

Then the algorithm that maps x onto (t,v) is the following: if  (x ≤ x_(M))  then begin remark  Neither  A  nor  B  are  yet  full, then  discrimination  is  based on  threshold if  (x  mod  C) < T  then begin t: = 1; v: = (x  div  C) ⋅ T + (x  mod  C); end else begin t: = 2; v: = (x  div  C) ⋅ (C − T) + ((x  mod  C) − T); end end else begin remark  A  or  B  is  already  full, then  no  more  discrimination, the remainder  of  A + B  is  mapped  to  the  set  not  yet  full, that  is to  say  that  with  tag  t_(M) t: = t_(M); v: = x − x_(M) + v_(M); end

The Mod-threshold term splitting algorithm is also shown on FIG. 2. The result of the algorithm is illustrated on FIG. 3 in the case of A=5, B=10, C=4 and T=2.

For some particular value to T and C the definition can be simplified. For instance when C=A+B and T=A, f is defined as: $\begin{matrix} {f\text{:}} & {A + B} & \rightarrow & {A \oplus B} \\ \quad & x & \mapsto & \left( {t,v} \right) \\ \quad & \quad & \quad & {{{with}\quad {if}\quad x} < A} \\ \quad & \quad & \quad & {\quad {{{then}\quad t} = {{1\quad {and}\quad v} = x}}} \\ \quad & \quad & \quad & {\quad {{{else}\quad t} = {{2\quad {and}\quad v} = {x - A}}}} \end{matrix}$

Another simplification occurs when given the values of D=A+B, C and T, A and B are chosen such that the comparison of x to x_(M) is not necessary, and only the comparison of the modulus to the threshold needs to be done. That is to say the mod-threshold term split function can be more simply written as: $\begin{matrix} {f\text{:}} & {A + B} & \rightarrow & {A \oplus B} \\ \quad & x & \mapsto & \left( {t,v} \right) \\ \quad & \quad & \quad & {{{with}\quad {if}\quad c} < T} \\ \quad & \quad & \quad & {{{then}\quad t} = {{1\quad {and}\quad v} = {{l \cdot T} + c}}} \\ \quad & \quad & \quad & {{{else}\quad t} = {{2\quad {and}\quad v} = {{l \cdot \left( {C - T} \right)} + c - T}}} \\ \quad & \quad & \quad & {{where}\left\{ \begin{matrix} {c = {x\quad {mod}\quad C}} \\ {l = {x\quad {div}\quad C}} \end{matrix} \right.} \end{matrix}$

Given D=A+B, C and T, the value of A and B for which this simplification occurs can be computed as: $\begin{matrix} \left\{ \begin{matrix} {A = {\left\{ {x \in {{D/\left( {x\quad {mod}\quad C} \right)} < T}} \right\} }} \\ {B = {\left\{ {x \in {{D/\left( {x\quad {mod}\quad C} \right)} \geq T}} \right\} }} \end{matrix} \right. & (7) \end{matrix}$

where |·| denotes the number of elements in a set.

This can also be more simply computed as: $\left\{ \begin{matrix} {A = {1 + {l_{A} \cdot T} + c_{A}}} & {where} & \left\{ \begin{matrix} {{I_{A} = {x_{A}\quad {div}\quad C}},} \\ {{c_{A} = {x_{A}\quad {mod}\quad C}},\quad {and}} \\ {x_{A} = {\max \left\{ {x \in {D/}} \right.}} \\ \left. {\left( {x\quad {mod}\quad C} \right) > T} \right\} \end{matrix} \right. \\ {B = {1 + {l_{B} \cdot \left( {C - T} \right)} + c_{B} - T}} & {where} & \left\{ \begin{matrix} {{I_{B} = {x_{B}\quad {div}\quad C}},} \\ {{c_{B} = {x_{B}\quad {mod}\quad C}},\quad {and}} \\ {x_{B} = {\max \left\{ {x \in {D/}} \right.}} \\ \left. {\left( {x\quad {mod}\quad C} \right) \geq T} \right\} \end{matrix} \right. \end{matrix} \right.$

Finally x_(A) and x_(B) can be more simply computed by the following algorithm: c  :=  (d − 1)mod  C; if  c < T  then   begin   x_(A)  :=  (D − 1);   x_(B)  :=  (D − 1) − (c + 1);   end else   begin   x_(B)  :=  (D − 1);   x_(A)  :=  (D − 1) − (c + 1) + T;   end

For instance D=10 C=5 T=2 will yield x_(B)=9, x_(A)=6, l_(A)=1, c_(A)=1, l_(B)=1, c_(B)=4, A=4 and B=6.

Selecting A and B such that the algorithm is simplified can result in less processing power requirement toprepare to interleaver table, or to compute the interleaver real time, or less Integrated Circuit surface, if this real time 20 term. splitting procedure is performed by an ASIC.

Elementary Factor Split φ_(n)

The elementary factor split φ_(n) function is splitting the first factor in the first term of S^((n−1)) into a x product of two sets. In fact the same principle could be used to split any factor of any term, but this is not needed for the definition thanks to the term and factor permutation functions defined above.

S^((n)) is such that from S^((n−1)) to S^((n)), nothing is changed except the first factor of the first term that is split by a bijection g into the x product of and .

In that case:

q_(n)=q_(n−1), i.e. same number of terms

∀i∈{2, . . . , q_(n−1)}T_(i) ^((n))=T_(i) ^((n−1)), i.e. the subsequent terms unchanged

p_(1,n)=p_(1,n−1)+1, i.e. one more factor in first term

∀j∈{2, . . . , p_(n−1)}N_(1,j+1) ^((n))=N_(1,j) ^((n−1))

A and B defined by AN₁ ^((n)), BN₂ ^((n)), and thus A·B=N₁ ^((n−1)) $\quad \begin{matrix} {{a\quad {bijection}}\quad} & {\quad {g\text{:}}} & {\quad {A \cdot B}} & \rightarrow & {A \times B} \\ \quad & \quad & x & \mapsto & \left( {{g_{1}(x)},{g_{2}(x)}} \right) \end{matrix}$ ϕ_(n)  is  built  as: $\begin{matrix} {\phi_{n}\text{:}} & S^{({n - 1})} & \rightarrow & S^{(n)} \\ \quad & x & \mapsto & \left\{ \begin{matrix} \left( {1,\left( {{g_{1}\left( x_{1} \right)},{g_{2}\left( x_{1} \right)},} \right.} \right. & {{{if}\quad t} = 1} \\ {{x_{2}\quad \ldots}\quad,{x_{p_{1,{n - 1}}}\left.  \right)\left.  \right)}} & \quad \\ x & {otherwise} \end{matrix} \right. \\ \quad & {with} & \quad & \quad \\ \quad & {x = \left( {t,v} \right)} & \quad & \quad \\ \quad & {and} & \quad & \quad \\ \quad & {v = \left( {x_{1},{x_{2}\quad \ldots \quad x_{p_{t,{n - 1}}}}} \right)} & \quad & \quad \end{matrix}$

The g bijections used by the elementary factor split function can be defined as follows: g:  A ⋅ B → A × B  main  factor  split  functions

There are many possible functions that all are computable on any current processor.

Here are some examples:

In the following for all x and y integer such that y>0:

x div y stands for the quotient of Euclidian division of x by y,

x mod y stands for the remainder of Euclidian division of x by y.

Note that ∀x ∀y y>0, (x mod y)∈, even for x≦0

The DIV-MOD factor split function: $\begin{matrix} {\quad {g\text{:}}} & {\quad {A \cdot B}} & \rightarrow & {A \times B} \\ \quad & x & \mapsto & \left( {{x\quad {div}\quad B},{x\quad {mod}\quad B}} \right) \end{matrix}$

This function is clearly bijective and:

g ⁻¹((a,b))=a×B+b

The div-mod factor split function is illustrated on FIG. 4.

The MOD-MOD factor split function:

This function can be used only when the greatest common divider of A and B is 1 (that is to say A{circumflex over ( )}B=1). $\begin{matrix} {\quad {g\text{:}}} & {\quad {A \cdot B}} & \rightarrow & {A \times B} \\ \quad & x & \mapsto & \left( {{x\quad {mod}\quad A},{x\quad {mod}\quad B}} \right) \end{matrix}$

The fact that the greatest common divider of A and B is 1 ensures the existence of two integers A′ and B′ such that B·B′+A·A′=1.

This allows to build easily the inverse of g as:

g ⁻¹((a,b))=b+ ^(I)(((a−b)·B′) mod A)·B=(a·B·B′+b·A·A′) mod (A·B)

The mod-mod factor split function is illustrated on FIG. 5.

Factorisation φ_(n)

The factorisation φ_(n) function groups several equal terms of a sum of sets, into a product of sets. This uses the obvious bijection between: $\underset{A\quad {times}}{\underset{}{B \oplus \ldots \oplus B}}{\quad \quad}{And}{\quad \quad}A \times B$

This bijection simply maps the tag-value couple (t,v) on the value only list (t−1,v), making of the tag t an element t−1 of .

The factorisation φ_(n) thus factorises the A first terms for S^((n−1)). In fact the same principle could be used to factorise any terms in S^((n−1)) provided that they are equal, but this is not needed for the definition thanks to the term permutation functions defined above.

S^((n)) and S^((n−1)) are such that:

A is positive non null integer such that q_(n)=q_(n−1)−A+1, because A terms of S^((n−1)) are merged in one,

∀i∈{1, . . . , A}T_(i) ^((n−1))=T₁ ^((n−1)), that is to say the A first terms of S^((n−1)) are identical,

∀i∈{2, . . . , q_(n)}T_(i) ^((n))=T_(i+A−1) ^((n−1)), that is to say the terms following the A first terms of S^((n−1)) are unaffected

φ_(n) is built as: $\begin{matrix} {\begin{matrix} {\phi_{n}\text{:}} & S^{({n - 1})} & \rightarrow & S^{(n)} & \quad \\ \quad & x & \mapsto & \left\{ \begin{matrix} \left( {{x_{1} + 1},\left( {x_{2},{x_{3}\quad \ldots}\quad,x_{p_{1,{n - 1}}}} \right)} \right) & {{{if}\quad t} = 1} \\ \left( {{t + A - 1},v} \right) & {otherwise} \end{matrix} \right. & \quad \end{matrix}{with}{x = \left( {t,v} \right)}{and}{v = \left( {x_{1},{x_{2}\quad \ldots \quad x_{p_{t,{n - 1}}}}} \right)}} & \quad \end{matrix}$

Distribution φ_(n)

The distribution φ_(n) function does the inverse operation of the factorisation φ′n that was described in the previous section. That is to say the first factor of the first term in S^((n−1)) becomes a tag for a sum.

In fact the same principle could be used on any factor of any term of S^((n−1)) provided that the term containing that factor has at least two factors, but this is not needed for the definition thanks to the term permutation functions defined above.

S^((n)) and S^((n−1)) are such that:

A is a positive non null integer such that N_(1,1) ^((n−1))=A

q_(n)=q_(n−1)+A−1, that is to say 1 term of S^((n−1)) is distributed over A terms of S^((n))

p_(1,n−1)>1 (first term of S^((n−1)) has at least two factors)

∀i∈{1, . . . , A}p_(i,n)=p_(1,n−1)−1, the A first terms of S^((n)) have one factor fewer—the one that was distributed—than the first term of S^((n−1))

∀i∈{1, . . . , A}∀j∈{1, . . . , p_(1,n)−1}N_(i,j) ^((n))=N_(1,j+1) ^((n−1)), the A first terms of S^((n)) are all identical and equal to the first term of S^((n−1)) without its first factor

∀i∈{2, . . . , q_(n−1)}T_(i+A−1) ^((n))=T_(i) ^((n−1)), the q_(n−1)−1 subsequent terms of S^((n−1)) are un-affected

φ_(n) is built as: $\begin{matrix} {\begin{matrix} {\phi_{n}\text{:}} & S^{({n - 1})} & \rightarrow & S^{(n)} & \quad \\ \quad & x & \mapsto & \left\{ \begin{matrix} \left( {{x_{1} + 1},\left( {x_{2},{x_{3}\quad \ldots}\quad,x_{p_{1,{n - 1}}}} \right)} \right) & {{{if}\quad t} = 1} \\ \left( {{t + A - 1},v} \right) & {otherwise} \end{matrix} \right. & \quad \end{matrix}{with}{x = \left( {t,v} \right)}{and}{v = \left( {x_{1},{x_{2}\quad \ldots \quad x_{p_{t,{n - 1}}}}} \right)}} & \quad \end{matrix}$

Elementary Interleaving φ_(n)

The elementary interleaving φ_(n) function permutes the elements of the first factor in the first term of S^((n−1)). In fact the same principle could be used to permute the elements of interleave any factor of any term, but this is not needed for the definition thanks to the term and factor permutation functions defined above.

S^((n)) and S^((n−1)) are of course equal.

In that case:

S^((n))=S^((n−1))

A an integer such that A=N_(1,1) ^((n)) •  a  bijection  ι:  A → A ϕ_(n)  is  built  as: $\begin{matrix} {\phi_{n}\text{:}} & S^{({n - 1})} & \rightarrow & S^{(n)} \\ \quad & x & \mapsto & \left\{ \begin{matrix} \left( {1,\left( {{\iota \quad \left( x_{1} \right)},x_{2},\ldots \quad,x_{p_{1,{n - 1}}}} \right)} \right) & {{{if}\quad t} = 1} \\ x & {otherwise} \end{matrix} \right. \end{matrix}$ with x = (t, v) and v = (x₁, x₂  …  x_(p_(t, n − 1)))

Here are some examples of ι bijection used by the elementary permutation function.

The tabulated ι function:

In that case the ι is implemented by a table in the memory of the processing unit. There are A entries in that table and ι(x) is written insthe (x+1)^(th) entry.

The table therefore requires s(A) bits (where s is defined in equation (6))

Affine-mod φ_(n)

The affine-mod φ_(n) function acts in the first terms of S^((n−1)) as if it was a vector space of dimension p_(1,n−1). In fact the same principle could be used on any term, but this is not needed for the definition thanks to the term permutation functions defined above.

S^((n)) and S^((n−1)) are of course equal.

In that case:

S^((n))=S^((n−1))

mp_(1,n−1)

an m line m column matrix U=[u_(i,j)] such that ∀i∈{1, . . . , m}∀j∈{1, . . . , m}u_(i,j) is integer (possibly negative)

a m line vector V=[v_(i)] such that:

∀i∈{1, . . . , m}v_(i) is integer (possibly negative) φ_(n) is built as: $\begin{matrix} {\phi_{n}\text{:}} & S^{({n - 1})} & \rightarrow & S^{(n)} \end{matrix}$ $\left. \left( {t,x} \right)\mapsto\left\{ {{\begin{matrix} {{\left( {1,y} \right)\quad {if}\quad t} = 1} \\ {\left( {t,x} \right)\quad {otherwise}} \end{matrix}\quad {with}\quad {for}\quad t} = {{1\quad x} = {{\left( {x_{1},{x_{2}\quad \ldots}\quad,x_{m}} \right)\quad y} = {{\left( {y_{1},{y_{2}\quad \ldots}\quad,y_{m}} \right)\quad {such}\quad {that}{\text{:}\quad\begin{bmatrix} z_{1} \\ \vdots \\ z_{m} \end{bmatrix}}} = {{{U \cdot \begin{bmatrix} x_{1} \\ \vdots \\ x_{m} \end{bmatrix}} + {V\quad {and}\quad {\forall{i \in {\left\{ {1,\ldots \quad,m} \right\} \quad y_{i}}}}}} = {z_{i}\quad {mod}\quad N_{i}^{(n)}}}}}}} \right. \right.$

Furthermore U and V are such that the φ_(n) obtained be bijective.

One sufficient condition to be fulfilled by U and V for the affine-mod φ_(n) to be bijective is the following one:

U is the product of two matrices U⁽¹⁾, and U⁽²⁾.

The elements of these matrices are denoted this way: ∀k∈{1,2}U^((k))=[u_(i,j) ^((k))]

U⁽¹⁾ is a sub-diagonal matrix with a diagonal of 1 or −1, that is to say: $\left\{ \begin{matrix} {{\forall{\left( {i,j} \right) \in \left\{ {1,\ldots \quad,m} \right\}^{2}}},{\left. {j > i}\Rightarrow u_{i,j}^{(1)} \right. = 0}} \\ {and} \\ {{\forall{i \in \left\{ {1,\ldots \quad,m} \right\}}},{u_{i,i}^{(1)} = {{1\quad {or}\quad u_{i,j}^{(1)}} = {- 1}}}} \end{matrix} \right.$

U⁽²⁾ is a diagonal matrix with for all i, i^(th) diagonal element primary with N_(1,i) ^((n)),

That is to say: $\left\{ \begin{matrix} {{\forall{\left( {i,j} \right) \in \left\{ {1,\ldots \quad,m} \right\}^{2}}},{\left. {j \neq i}\Rightarrow u_{i,j}^{(2)} \right. = 0}} \\ {and} \\ {{\forall{i \in \left\{ {1,\ldots \quad,m} \right\}}},{u_{i,i}^{(2)}\quad {and}\quad N_{1,i}^{(n)}\quad {greatest}\quad {common}\quad {divider}\quad {is}\quad 1}} \end{matrix} \right.$

Product is done in this order: U=U⁽²⁾·U⁽¹⁾

Note: U⁽¹⁾ can be also super-diagonal (elements under diagonal are null) instead of sub-diagonal, this comes up to the same thanks to the factor permutation φ_(n) function.

Annexe on Affine-mod Functions

Here is given a proof of the sufficient condition that was given to build the affine-mod φ_(n) functions. Let us recall the definition of the affine-mod function where we have omitted the n index that brings no information here, and we have replaced it by a U index, meaning that this is the φ that is generated by some matrix U. For alleviating the notation we have also omitted the term index (specifying that we are working on the first term of S^((n−1))). $\begin{matrix} {\phi_{U}\text{:}} & {N_{1} \times N_{2} \times \ldots \times N_{p}} & \rightarrow & {N_{1} \times N_{2} \times \ldots \times N_{p}} \end{matrix}$ (x₁, x₂  …  x_(p)) ↦ (y₁, y₂  …  y_(p)) $\quad {{{such}\quad {that}{\text{:}\quad\begin{bmatrix} z_{1} \\ \vdots \\ z_{m} \end{bmatrix}}} = {{{U \cdot \begin{bmatrix} x_{1} \\ \vdots \\ x_{p} \end{bmatrix}} + {V\quad {and}\quad {\forall{i \in {\left\{ {1,\ldots \quad,p} \right\} \quad y_{i}}}}}} = {z_{i}\quad {mod}\quad N_{i}}}}$

Since the from and to sets are the same and are finite, it is cleady necessary and sufficient to show that φ_(U) is injective in order to show that φ_(U) is bijective.

Let Z denote the set of signed integers, then bijectivity of φ_(U) is equivalent to the injectivity definition, i.e.: $\left. \begin{matrix} {\forall{\left( {q_{1},{q_{2}\quad \ldots \quad q_{p}}} \right) \in Z^{p}}} \\ {\forall{\left( {x_{1},{x_{2}\quad \ldots \quad x_{p}}} \right) \in {N_{1} \times N_{2} \times \ldots \times N_{p}}}} \\ {\forall{\left( {y_{1},{y_{2}\quad \ldots \quad y_{p}}} \right) \in {N_{1} \times N_{2} \times \ldots \times N_{p}}}} \end{matrix} \right\},{{{U \cdot \begin{bmatrix} x_{1} \\ \vdots \\ x_{p} \end{bmatrix}} + V} = {\left. {{U \cdot \begin{bmatrix} y_{1} \\ \vdots \\ y_{p} \end{bmatrix}} + V + \begin{bmatrix} {q_{1} \cdot N_{1}} \\ \vdots \\ {q_{p} \cdot N_{p}} \end{bmatrix}}\Rightarrow\begin{bmatrix} x_{1} \\ \vdots \\ x_{p} \end{bmatrix} \right. = \begin{bmatrix} y_{1} \\ \vdots \\ y_{p} \end{bmatrix}}}$

Then by a simple subtraction, by using linearity of U, and by making some variable change on x_(i)−y_(i) it comes that bijectivity of φ_(U) is equivalent to $\left. \begin{matrix} {\forall{\left( {q_{1},{q_{2}\quad \ldots \quad q_{p}}} \right) \in Z^{p}}} \\ {\forall{\left( {x_{1},{x_{2}\quad \ldots \quad x_{p}}} \right) \in {\left\lbrack {{{- N_{1}} + 1},{N_{1} - 1}} \right\rbrack \times \ldots \times \left\lbrack {{{- N_{p}} + 1},{N_{p} - 1}} \right\rbrack}}} \end{matrix} \right\},{{U \cdot \begin{bmatrix} x_{1} \\ \vdots \\ x_{p} \end{bmatrix}} = {\left. \begin{bmatrix} {q_{1} \cdot N_{1}} \\ \vdots \\ {q_{p} \cdot N_{p}} \end{bmatrix}\Rightarrow\begin{bmatrix} x_{1} \\ \vdots \\ x_{p} \end{bmatrix} \right. = \begin{bmatrix} 0 \\ \vdots \\ 0 \end{bmatrix}}}$

Where in the equation above all [a,b] denotes an interval of signed integers comprised between a and b inclusive.

Now let us assume that U is a sub-diagonal matrix, with a diagonal of 1 or −1, that is to say: $\left\{ \begin{matrix} {{\forall{\left( {i,j} \right) \in \left\{ {1,\ldots \quad,m} \right\}^{2}}},} & {\left. {j > i}\Rightarrow u_{i,j} \right. = 0} \\ {and} & \quad \\ {{\forall{i \in \left\{ {1,\ldots \quad,m} \right\}}},} & {u_{i,i} = {{1\quad {or}\quad u_{ij}} = {- 1}}} \end{matrix} \right.$

(with of course all the elements of U integers).

If such a condition is fuilfilled then U is clearly inversible and the inverse U⁻¹ of U is also a sub-diagonal matrix with a diagonal of 1 or −1 and all elements still integers. This is trivially derived by the Gauss pivot algorithm applied to inverse matrix U.

The equation ${U \cdot \begin{bmatrix} x_{1} \\  \cdot \\  \cdot \\ x_{p} \end{bmatrix}} = \begin{bmatrix} {q_{1} \cdot N_{1}} \\  \cdot \\  \cdot \\ {q_{p} \cdot N_{p}} \end{bmatrix}$

can be written: $\begin{bmatrix} x_{1} \\  \cdot \\  \cdot \\ x_{p} \end{bmatrix} = {U^{- 1} \cdot \begin{bmatrix} {q_{1} \cdot N_{1}} \\  \cdot \\  \cdot \\ {q_{p} \cdot N_{p}} \end{bmatrix}}$

Let us denote u′_(i,j) the elements of U⁻¹=[u′_(i,j)]

U⁻¹ is a subdiagonal matrix with all element integer and a diagonal of 1 or −1.

Then by recurrence:

x₁ is clearly null, because x₁=u′_(1,1) ⁻·q₁·N₁, q₁ and u′_(1,1) are integer, and 0 is the only multiple N₁ in [−N₁+1, N₁−1]

Now for all j with 1≦j<p, if ∀i 1≦i≦j, x_(i)=0, then we have x_(j+1)=u′_(j+1,j+1)·q_(j+1)·N_(j+1), and similarly we can deduce that x_(j+1) is also null.

Now let us assume that U=U⁽²⁾·U⁽¹⁾, where U⁽¹⁾ is a subdiagonal matrix with all elements integers and a diagonal of 1 or −1, and U⁽²⁾ is a diagonal matrix whose for all i, i^(th) diagonal element is primary with N_(i).

Let us assume that for some (q₁, . . . , q_(p)) integers, and for some (x₁, . . . , x_(p)) in [−N₁+1, N₁−1]x . . . x[−N_(p)+1, N_(p)−1] we have: ${U \cdot \begin{bmatrix} x_{1} \\  \cdot \\  \cdot \\ x_{p} \end{bmatrix}} = \begin{bmatrix} {q_{1} \cdot N_{1}} \\  \cdot \\  \cdot \\ {q_{p} \cdot N_{p}} \end{bmatrix}$

Let us call $\begin{bmatrix} y_{1} \\  \cdot \\  \cdot \\ y_{p} \end{bmatrix} = {U^{(1)} \cdot \begin{bmatrix} x_{1} \\  \cdot \\  \cdot \\ x_{p} \end{bmatrix}}$

we have therefore: ${U^{(2)} \cdot \begin{bmatrix} y_{1} \\  \cdot \\  \cdot \\ y_{p} \end{bmatrix}} = \begin{bmatrix} {q_{1} \cdot N_{1}} \\  \cdot \\  \cdot \\ {q_{p} \cdot N_{p}} \end{bmatrix}$

That is to say: $\begin{bmatrix} {u_{1,1}^{(2)} \cdot y_{1}} \\  \cdot \\  \cdot \\ {u_{p,p}^{(2)} \cdot y_{p}} \end{bmatrix} = \begin{bmatrix} {q_{1} \cdot N_{1}} \\  \cdot \\  \cdot \\ {q_{p} \cdot N_{p}} \end{bmatrix}$

For all i from 1 to m, N_(i) divides u_(i,i) ⁽²⁾·y_(i), and is primary with u_(i,i) ⁽²⁾ by definition of U⁽²⁾, then, according to Gauss theorem, it also divides y_(i). In other word we can find some q₁′, . . . , q_(p)′ integers such that: $\begin{bmatrix} y_{1} \\  \cdot \\  \cdot \\ y_{p} \end{bmatrix} = \begin{bmatrix} {q_{1}^{\prime} \cdot N_{1}} \\  \cdot \\  \cdot \\ {q_{p}^{\prime} \cdot N_{p}} \end{bmatrix}$

that is to say: ${U^{(1)} \cdot \begin{bmatrix} x_{1} \\  \cdot \\  \cdot \\ x_{p} \end{bmatrix}} = \begin{bmatrix} {q_{1}^{\prime} \cdot N_{1}} \\  \cdot \\  \cdot \\ {q_{p}^{\prime} \cdot N_{p}} \end{bmatrix}$

Now U⁽¹⁾ is a sub-diagonal matrix of integers with diagonal elements all equal to 1 or to −1. Then, as we have already shown it above, this in-volves that ${\begin{bmatrix} x_{1} \\  \cdot \\  \cdot \\ x_{p} \end{bmatrix} = 0},$

and since (q₁, . . . , q_(p)) were any integers, and (x₁, . . . , x_(p)) any elements of [−N₁+1, N₁−1]x . . . x[−N_(p)+1, N_(p)−1], this involves that φ_(U) is injective, and therefore bijective, thus concluding the proof.

Elementary Factor Merge φ_(n)

In order to get back to S^((k))= in the end, some x product of sets must also sometimes be merged. The elementary factor merge φ_(n) function merges the two first factors of the first term of S^((n−1)). In fact the same principle could be used on any pair of factors of any term that have at least two factors, but this is not needed for the definition thanks to the term and factor permutation functions defined above.

In that case:

q_(n)=q_(n−1), i.e. same number of terms

p_(1,n−1)≧2 and p_(1,n)=p_(1,n−1)−1 i.e. one factor fewer in first term

∀i∈{2, . . . , q_(n)}T_(i) ^((n))=T_(i) ^((n−1)), i.e. terms other than the first one are unchanged

∀j∈{3, . . . , p_(1,n−1)}N_(1,j−1) ^((n))=N_(1,j) ^((n−1)), i.e. the p_(1,n−1)−2 last factors of T₁ ^((n−1)) are unaffected

A and B defined by AN_(1,1) ^((n−1)), BN_(1,2) ^((n−1)), and thus A·B=N_(1,1) ^((n))

a bijection $\begin{matrix} {h\text{:}} & {\quad {A \times B}} & \rightarrow & {A \cdot B} \\ \quad & \left( {x_{1},x_{2}} \right) & \mapsto & {h\left( \left( {x_{1},x_{2}} \right) \right)} \end{matrix}$

φ_(n) is built as: $\begin{matrix} {\phi_{n}\text{:}} & S^{({n - 1})} & \rightarrow & S^{(n)} \\ \quad & x & \mapsto & \left\{ \begin{matrix} \left( {1,\left( {{h\left( {x_{1},x_{2}} \right)},{x_{3}\quad \ldots}\quad,x_{p_{1,{n - 1}}}} \right)} \right) & {{{if}\quad t} = 1} \\ x & {otherwise} \end{matrix} \right. \\ \quad & {with} & \quad & \quad \\ \quad & {x = \left( {t,v} \right)} & \quad & \quad \\ \quad & {and} & \quad & \quad \\ \quad & {v =} & \quad & \quad \\ \quad & \left( {x_{1},{x_{2}\quad \ldots \quad x_{p_{t,{n - 1}}}}} \right) & \quad & \quad \end{matrix}$

The h bijections used by the elementary merge function can be defined as follows: h:  A × B → A ⋅ B  MAIN  FACTOR  MERGE  FUNCTIONS

There are many possible functions that all are computable on any current processor.

Here is one example:

In the following for all x and y integer such that y>0:

x div y stands for the quotient of Euclidian division of x by y,

x mod y stands for the remainder of Euclidian division of x by y.

Note that ∀x ∀y y>0, (x mod y)∈, even for x≦0

The DIV-MOD factor merge function: $\begin{matrix} {h\text{:}} & {A \times B} & \rightarrow & {A \cdot B} \\ \quad & \left( {x_{1},x_{2}} \right) & \mapsto & {{B \cdot x_{1}} + x_{2}} \end{matrix}$

This function is clearly bijective and its inverse function is the div-mod factor split g bijection exemplified in the definition of the elementary factor split φ_(n) function:

Note: it is not needed to define a mod-mod factor merge h function that would be the inverse of the mod-mod factor split g function defined for the elementary factor split φ_(n), that is to say:

g(x)=(x mod A, x mod B)

g⁻¹((a,b))=b+(((a−b)·B′) mod A)·B

As a matter of fact the φ_(n) that would result from this mod-mod factor merge h would be the composition of an affine-mod φ_(n) of matrix defined by block: $U = {\overset{\overset{U^{(2)}}{}}{\begin{bmatrix} \quad & \quad & \quad & \quad \\ \quad & {Id} & \quad & O_{v} \\ \quad & \quad & \quad & \quad \\ \quad & O_{H} & \quad & \begin{matrix} B^{\prime} & 0 \\ 0 & 1 \end{matrix} \end{bmatrix}} \cdot \overset{\overset{U^{(1)}}{}}{\begin{bmatrix} \quad & \quad & \quad & \quad \\ \quad & {Id} & \quad & O_{v} \\ \quad & \quad & \quad & \quad \\ \quad & O_{H} & \quad & \begin{matrix} 1 & {- 1} \\ 0 & 1 \end{matrix} \end{bmatrix}}}$

and of null vector V, and of the elementary factor merge function using the div-mod factor merge h function.

Above Id, O_(V), and O_(H) are respectively the identity (m−2)×(m−2) matrix (diagonal of 1), the null (m−2)×2 matrix and the null 2×(m−2) matrix.

Elementary Term Merge φ_(n)

In order to get back to in the end, some sum of sets must also sometimes be merged. The elementary term merge φ_(n) function merges the two first factors respectively of the two first terms of S^((n−1)), when the two first terms have the same subsequent factors, that can therefore be factorised. In fact the same principle could be used on any pair of factor of any pair of terms in S^((n−1)), provided that they can be factorised in the form (A ⊕ B) × A₁ × … × A_(p).

In that case:

q_(n−1)≧2 and q_(n)=q_(n−1)−1, i.e. one fewer term

∀j∈{3, . . . , p_(n−1)}T_(j−1) ^((n)=T) _(j) ^((n−1)), i.e. remaining terms unchanged

p_(1,n−1)=p_(2,n−1)=p_(1,n), i.e. the two first terms of S^((n−1)) have the same number of factors, that is also that of the first term of S^((n))

∀j∈{2, . . . , p_(1,n−1)}N_(1,j) ^((n−1))=N_(2,j) ^((n−1)), that is to say the two first term can be factorised

A and B defined by AN_(1,1) ^((n−1)), BN_(2,1) ^((n−1)), and thus A+B=N_(1,1) ^((n))

a bijection κ:  A ⊕ B → A + B ϕ_(n)  is  built  as: $\begin{matrix} {\phi_{n}\text{:}} & S^{({n - 1})} & \rightarrow & S^{(n)} \\ \quad & x & \mapsto & \left\{ \begin{matrix} \left( {1,{\kappa \left( \left( {t,x_{1}} \right) \right)},} \right. & {{{{if}\quad t} = {1\quad {or}}}\quad} \\ {x_{2},\ldots \quad,{x_{p_{1,{n - 1}}}\left.  \right)}} & {\quad {t = 2}} \\ \left( {{t - 1},v} \right) & {otherwise} \end{matrix} \right. \\ \quad & {With} & \quad & \quad \\ \quad & {x = \left( {t,v} \right)} & \quad & \quad \\ \quad & {and} & \quad & \quad \\ \quad & {v = \left( {x_{1},{x_{2}\quad \ldots \quad x_{p_{t,{n - 1}}}}} \right)} & \quad & \quad \end{matrix}$

The term merge κ bijections used by the elementary term merge function can be defined as follows: κ:  A ⊕ B → A + B  MAIN  TERM  MERGE  FUNCTIONS

There are many possible functions that all are computable on any current processor.

As an example of κ, the mod-threshold term merge function will be described hereafter:

In this function, a merge function is made that is the inverse of the mod-threshod term split function that was already explained.

Similarly we have two constants C and T such that: $\begin{matrix} {\kappa \text{:}} & {A \oplus B} & \rightarrow & {A + B} \\ \quad & \left( {t,v} \right) & \mapsto & {x\quad {defined}\quad {by}\quad {the}\quad {algorithm}\quad {below}} \end{matrix}$

Three constants x_(M), v_(M) and t_(M) are derived from A, B and C according to the following definitions and formulas (the formulas are the same as for the mod-threshold term splitting function):

x_(M) is the greatest x while neither nor are empty.

t_(M) is the tag of the set ( or ) not yet empty.

v_(M) is the greatest value of the set not yet empty while both sets are not yet empty. $X_{M}\overset{\Delta}{=}{\max \left\{ {x \in {{A + B}/\left( {\begin{matrix} {{{l \cdot T} + c} < A} & {{{if}\quad c} < T} \\ {and} & \quad \\ {{{l \cdot \left( {C - T} \right)} + c - T} < B} & {otherwise} \end{matrix},{{{where}\quad l} = {x\quad {div}\quad C}},{{{and}\quad c} = {x\quad {mod}\quad C}}} \right.}} \right\}}$ $t_{M}\overset{\Delta}{=}\left( \begin{matrix} 1 & {{{if}\quad \left( {\left( {x_{M} + 1} \right){mod}\quad C} \right)} \geq T} \\ 2 & {otherwise} \end{matrix} \right.$ $v_{M}\overset{\Delta}{=}\left( \begin{matrix} {\max \left\{ {{v/{\exists{x \leq x_{M}}}},\left( \left. \begin{matrix} {l\overset{\Delta}{=}{x\quad {div}\quad C}} \\ {and} \\ {c\overset{\Delta}{=}{x\quad {mod}\quad C}} \end{matrix}\Rightarrow\left( \begin{matrix} {c < T} \\ {and} \\ {v = {{l \cdot T} + c}} \end{matrix} \right. \right. \right.} \right\}} & {{{if}\quad t_{M}} = 1} \\ {\max \left\{ {{v/{\exists{x \leq x_{M}}}},\left( \left. \begin{matrix} {l\overset{\Delta}{=}{x\quad {div}\quad C}} \\ {and} \\ {c\overset{\Delta}{=}{x\quad {mod}\quad C}} \end{matrix}\Rightarrow\left( \begin{matrix} {c \geq T} \\ {and} \\ {v = {{l \cdot \left( {C - T} \right)} + c - T}} \end{matrix} \right. \right. \right.} \right\}} & {{{if}\quad t_{M}} = 2} \end{matrix} \right.$

Then the algorithm that maps (t,v) onto x is the following: if  v ≤ v_(M)  or  t ≠ t_(M)  then begin remark  Neither  A  nor  B  are  yet  empty, then  discrimination  is based  on  tag if  t = 1  then x := (v  div  T) ⋅ C + (v  mod  T); else x := T + (v  div  (C − T)) ⋅ C + (v  mod  (C − T)); end else begin remark  A  or  B  is  already  empty, then  no  more  discrimination, the  remainder  of  the  set  not  yet  empty  is  mapped  to  A + B x := v − v_(M) + x_(M);

Implementation Matters

In fact the method of the invention is not tied to any particular implementation scheme. The method only defines mathematically a permutation, with a definition allowing less tabulation at the expense of more processing.

As was already suggested above, the computation of I⁻¹ from its φ_(k)°φ_(k−1) . . . °φ₁ definition might be done by-a general purpose processor, typically during connection time, in order to prepare a look-up table to be used during interleaving. But as well, this computation might also be done by dedicated hardware circuitry, computing on the fly I⁻¹(i) from its φ_(k)°φ_(k−1) . . . °φ₁ definition in order to interleave the (i+1)^(th) symbol of data when this symbol is to be interleaved. Typically a hardware circuitry could use a pipeline architecture where each step in the pipeline more or less correspond to one φ_(n), or one compound φ_(n+p)° . . . °φ_(n). This kind of architecture is applicable because in order to compute on the fly I⁻¹(i), what matters is not the total computation time of I⁻¹ (i), but the rate at which they can be computed. This is because the “i” arguments of I⁻¹(i) come in a predefined order.

When a hardware architecture is used, the operations implemented are not necessarily using the mathematical definition of φ_(n). In order to reduce the circuit size, there can be a mixture of arithmetic units, and of ROM tables. For instance a first x splitting step can be done arithmetically, then the intermediate steps can be done by look up table, and a final x merging step can be done arithmetically again.

When a general purpose processor is used, neither are the operations implemented necessarily directly using the mathematical definition of φ_(n). There might be some optimisations:

For instance when N is a power of 2, then splitting into a product of sets whose respective element numbers are also power of two does not need any division or modulo computation since it can be done by simple bit manipulation such as ORs, ANDs and bit shifts. For instance when mapping to by the div-mod factor split function, then the image of x is (y,z), where if x=b7b6b5b4b3b2b1b0 in binary notation, then y=b7b6b5 and z=b4b3b2b1b0. To take it in more practical terms, if x=10110001, then y=101 and z=10001.

Also still in the case of a number N of elements that is a power of two, and when there is only one term (or when only one term of size N in the sum is considered), some factor permutations are implementable by classical processing units instructions such as bit rotation or quartet swap. Let us for instance consider for N=256 the 16×16 rectangular interleaver. The 16×16 rectangular intedeaver comprises in its φ_(n) compound definition a factor permutation that is swapping the two factors. In fact, the interleaver permutation can be shown to be not much more than a quartet swap which can be done in one instruction on some processing machines.

Non-uniqueness of Definition

The inventive method provides means to define an interleaver using less tabulation at the expense of more processing, so that to reduce ROM size requirement.

The definition of the interleaver provided by the method might be not unique, since for instance:

consecutive splitting steps can sometimes be done in several different ways; for instance a first way to map onto is a first divmod splitting function φ₁ mapping onto followed by a second div-mod split φ₄°φ₃°φ₂ mapping onto (φ₂ and φ₄ are the factor permutation function respectively bringing in first position, and then in first position again); a second way is a first div-mod splitting function φ′₁ mapping onto , followed by a second div-mod split φ′₂ mapping onto ; both ways yield the same mapping (φ₄°φ₃°φ₂°φ₁=φ₂°φ₁°),

the order of compound of two functions whose action is limited to different factor or terms can be inverted,

it is possible to build a function φ_(n) and its inverse by the inventive method, then you can always insert a compound of several φ_(n) into the compound defining I⁻¹, provided that the compound of these several φ_(n) sums up to the identical function, and has no overall effect, for instance when I⁻¹=φ_(k)° . . . °φ₂°φ₁ is an interleaver over , and N=L·C, then if φ_(k+1) is defined as the div-mod factor split function that map to and φ_(k+2) as the div-mod factor merge function that maps to , then I⁻¹ can also be defined as I⁻¹=φ_(k+2)°φ_(k+1)°φ_(k)° . . . °φ₂°φ₁ because the compound φ_(k+2)°φ_(k+1) has no overall effect.

the classification of the φ_(n) might not be unique, some φ_(n) can be found under two categories. For instance when all the N_(1,j) ^((n)) are equal then a “factor permutation” φ_(n) can also be defined as an “affine-mod” φ_(n) with V=0 and U a permutation matrix.

Example of Inventive Method Applied to Known Interleavers

The inventive method allows to build interleavers by mixing tabulation (or processing not defined in the invention) and processing (defined in the invention). Here is shown that some well known interleavers can be defined with the inventive method to be implemented in an interleaver device according to the invention.

1—The Rectangular Interleaver

According to the invention, the classical rectangular interleaver I of depth N=L·C with L lines and C column block is written as:

I ⁻¹=φ₃°φ₂°φ₁

Where:

φ₁ is the div-mod elementary factor split function splitting to

φ₂ is the factor permutation function for σ=(2,1), that is to say φ₂ is mapping on

φ₃ is the div-mod elementary factor merge function merging to

The rectangular interleaver is illustrated on FIG. 6.

2—The Diagonal Interleaver

The usual diagonal interleaver I depth N=L·C, with L lines and C column block, where lines are written first and then diagonal are read, when j^(th) diagonal begins at the first element of j^(th) line is written as:

I ⁻¹=φ₃°φ₂°φ₁

Where:

φ₁ is the div-mod elementary factor split function splitting to

φ₂ is the affine-mod function with V=0 and $U = \begin{bmatrix} 1 & 1 \\ 0 & 1 \end{bmatrix}$

φ₃ is the div-mod elementary factor merge function merging to

3—The Truncated Rectangular Interleaver

Truncated rectangular interleavers are used in MIL interleavers which are defined in ETSI SMG2 UMTS-L1 EG Tdoc 98/273 “Multi-stage interleaving (MIL) method for Turbo codes” by “NTT DoCoMo”. In a truncated rectangular interleaver the N input data is written along lines in a block of L′ lines and C′ columns, with C′ which is not a divider of N (and L′ great enough for L′·C′≧N). Then the data is read out along columns.

The truncated rectangular interleaver is illustrated on FIG. 7 with N=20 and C′=6.

The truncated rectangular interleaver is defined by the method of the invention as the sum of two rectangular interleavers.

I ⁻¹=φ₈°(φ₇°φ₆°φ₅)°(φ₄°φ₃°φ₂)°φ₁

Where:

φ₁ is the mod-threshold elementary term split function, where C=C′ and T=N mod C′.

φ₁ to with

N ₁=(N div C′+1)·(N mod C′), and

N ₂=(N div C′)·(C′−(N mod C′))

(φ₄°φ₃°′φ₂) is the first rectangular interleaver that is applied to with parameters:

L=(N div C′+1), and

C=(N mod C′)

(φ₇°φ₆°φ₅)is the second rectangular interleaver that is applied to with parameters:

L=(N div C′), and

C=C′−(N mod C′)

φ₈ is the term merge function with C=N₁+N₂ and T=N₁.

4—The Mil Interleaver

The MIL interleavers defined in ETSI SMG2 UMTS-L1 EG T doc 98/273 “Multi-stage interleaving (MIL) method for Turbo codes” by “NTT Do-CoMo” can also be constructed by the method of the invention. The MIL interleaver is defined recursively, and the method of the invention is by essence recursive.

A MIL interleaver of depth N=L·C is defined as the succession of the following steps:

1) First write the input data along the lines of the rectangular block of L lines and C columns;

2) Then interleave each line by either a rectangular interleaver, or a trunctated rectangular interdaver, or a MIL interleaver; and

3) Finally read the block by columns.

The first step consists of (φ₂°φ₁), where φ₁ is the div-mod factor split function applied to and mapping it to and φ₂ is the distribution function that maps N

where each term consists of a line of the block.

The second steps consists in applying a rectangular, a truncated rectangular or a MIL interleaver to each term. As already seen, rectangular and truncated rectangular intedeaver can be generated by the method of the invention, then this second step is also within the invention.

The third step consisting of reading the block by column can be simply written as (φ_(k)°φ_(k−1)°φ_(k−2)), where φ_(k−2) is the factorisation function mapping ${\underset{L\quad {times}}{\underset{}{C \oplus \ldots \oplus C}}\quad {to}\quad L \times C},$

φ_(k−1) a factor permutation mapping to , and φ_(k) the div-mod factor merge.

In conclusion MIL interleavers are a subset of the interleavers that can be generated by the inventive method.

5—Other Interleavers

The inventive method is open to embed other interleavers into the inventive interleavers by means of the elementary interleaving function. After decomposing S⁽⁰⁾= into a sum of products of sets of the form, an interleaver not defined by this document can be applied to only one of this factor set: this is what is called elementary interleaving in this document.

In the definition of many existing intedeaver a similar method is also used, for instance in ETSI SMG2 UMTS-L1 EG Tdoc 98/337 “A General Turbo Interleaver Design Technique with Near Optimal Performance” by “Hughes Network Systems”, we can read that such a process is used:

writing the symbol in a rectangular block along the rows: this corresponds to a div-mod factor split of to

then operating on each row separately: this corresponds to a distribution of product in a sum of L terms . . . each term being a row,

shuffling each row by some rule derived from Galois field arithmetic: this corresponds to an elementary interleaving applied to the term of which the row is consisting.

permutating the rows: this can be expressed either as a term permutation, or as factorising to again, and making an elementary interleaving bearing on the dimension.

reading by column: this is also interpreted in the inventive method, we first swap the two factors in by a factor permutation, then make a div-mod factor merge.

The invention brings some methodology allowing to define an interleaver in a unified formal language. This would ease specification of interleavers by defining the compound or sequence of the φ_(n). Such a specification would be without ambiguity, and even possibly in a language that is directly machine processable. Such a sequence can be coded in a dedicated binary format, for instance a TLV format, where T (tag) gives the type of φ_(n) (factor split, term split, affine-mod, etc.) and the LV (length+value) gives the characteristics of φ_(n), for instance if φ_(n) is affine-mod, the matrix U and the vector V. Such a coded format can be used to defined a great variety of interleavers in a device at a very low ROM memory cost. Also the same format can be used on an interface to negotiate which interleaver is to be used.

The term split is also of a great interest. Many arithmetic interleavers (e.g. GF interleaver as defined in ETSI SMG2 UMTS-L1 EG Tdoc 98/337 “A General Turbo Interleaver Design Technique with Near Optimal Performance” by “Hughes Network Systems”, for N=2^(m)) are primarily defined for some N that has good properties. When an interleaver with an N that has not such good properties needs to be built, then an arithmetic interleaver with N′>N and N′ having the good properties is built, and then punctured down to N. Puncturing an interleaver is not done at a very high processing power when it consists in modifying a RAM table. However these forces an implementation where first the interleaver is prepared in a RAM table, and then this RAM table is used. Implementation where the interleaver function is computed real time by an ASICs cannot be realistically considered with puncturing. Thanks to the term splitting function instead of searching for N′ with good arithmetic properties and N′>N, one can find N′ with good arithmetic properties such that N′<N, and then apply the arithmetic interleaver to a term of size N′, thus avoiding any puncturing.

Puncturing of an interleaver is shown on FIG. 8. An interleaver I₈ of depth 8 is punctured down to a depth of 5 to form an interleaver I₅. In the upper part of the figure a table where the values of I₈ ⁻¹ are shown. The table entry number (above the table) is the value of i, and the entry value (inside the table) is the value of I₈ ⁻¹(i). In other words we have I₈ ⁻¹(0)=3, I₈ ⁻¹(1)=0, etc. Then all the entries such that I₈ ⁻¹(i)≧5 are to be punctured. These entries are marked on the figure by a triangle. Puncturing consists in moving some part of the table, for instance the entry in position 4 is moved to position 2 so that I₅(2)=I₈(4)=1.

After puncturing, the 5 first entries of the table contain only numbers ranging from 0 to 4. 

What is claimed is:
 1. An interleaver device configured to interleave a data set, comprising: an interleaver driver; a processing unit including a data processor configured to operate as an interleaver under the control of the interleaver driver; a data input device configured to input the data set to be interleaved; and a data output device configured to output an interleaved data set, said interleaver driver including, a mapping processor configured to calculate a set of bijective elementary functions (φ_(n)) and supply a mapping of the interleaver to the data processor, and an interleaver definition generator configured to supply an interleaver definition to said mapping processor, said interleaver definition comprising a compound function (φ_(k)O . . . oφ₁) of at least one bijective elementary function drawn from said set of bijective elementary functions (φ_(n)).
 2. The interleaver device according to claim 1, said interleaver driver comprising: a read only memory (22) configured to supply a plurality of parameters corresponding to said set of the bijective elementary functions (φ_(n)) to said mapping processor.
 3. The interleaver device according to claim 1, said interleaver definition generator comprising: an interleaver definition input module.
 4. The interleaver device according to claim 1, said set of bijective elementary fiuctions (φ_(n)) comprising: a plurality of functions having an origin set and a destination set each expressed as a sum of a product of factor sets of successive integers, said plurality of functions including, an elementary term split function configured to split a factor of a term of said set of bijective elementary functions (φ_(n)) into a sum of two sets; an elementary factor split function configured to split said factor of said term of said set of bijective elementary functions (φ_(n)) into a product of two sets; an elementary permuting function configured to permute elements of said a factor of said term of said set of bijective elementary functions (φ_(n)); an elementary affine-mod function configured to affine map said term of said set of bijective elementary functions (φ_(n)) as a subset of vector space with a vector dimension equal to a predetermined number of factors and to select a modulus of a coordinate corresponding to a size of a respective factor set; an elementary factor merge function configured to merge two factors of said term so as to merge a product of sets into an elementary factor merged set; and an elementary term merge function configured to merge two factors respectively of two terms of said set of bijective elementary functions (φ_(n)) so as to merge a sum of sets into an elementary term merged set, said two terms selected to have common factors.
 5. The interleaver device according to claim 4, said plurality of functions further comprising: a elementary term permutation function; and a elementary factor permutation function, wherein said elementary term split function is configured to split a first factor of a first term of said set of bijective elementary functions (φ_(n)) into a sum of two sets; said elementary factor split function is configured to split said first factor of said first term of said set of bijective elementary functions (φ_(n)) into a product of two sets; said elementary permuting function is configured to permute elements of said first factor of said first term of said set of bijective elementary functions (φ_(n)); said elementary factor merge function is configured to merge the said first factor and a second factor of the first term of said set of bijective elementary functions (φ_(n)); and said elementary term merge function is configured to merge the two first factors respectively of the two first terms of said set of bijective elementary functions (φ_(n)), said two first terms selected to have common subsequent factors.
 6. The interleaver device according to claim 4, wherein said elementary factor split function is configured to split one factor of a term in said set of bijective elementary functions (φ_(n)) with a first mapping of and a second mapping of x→(x div B, x mod B).
 7. The interleaver device according to claim 4, wherein said elementary factor split function is configured to split one factor of a term in said set of bijective elementary functions (φ_(n)) with a first mapping of and a second mapping of x→(x div B, x mod B).
 8. The interleaver device according to claim 4, wherein said elementary factor merge function is configured to merge two factor and of a term in said set of bijective elementary ftmnctions (φ_(n)) with a first mapping of and a second mapping of (x₁,x₂)→B·x₁+x₂.
 9. The interleaver device according to claim 4, wherein said elementary affine-mod function corresponds to an affine function of matrix U equal to aproduct U=U⁽²⁾·U⁽¹⁾ of a first matrix U⁽¹⁾=[u⁽¹⁾] and a second matrix U^((2)=[u) ⁽²⁾], wherein said first matrix U⁽¹⁾ is equal to a sub-diagonal matrix with a diagonal of 1 or −1 $\left\{ \begin{matrix} {{\forall{\left( {i,j} \right) \in \left\{ {{1\quad \ldots}\quad,m} \right\}^{2}}},{\left. {j > i}\Rightarrow u_{i,j}^{(1)} \right. = 0}} \\ {and} \\ {{\forall{i \in \left\{ {1,\ldots \quad,m} \right\}}},{u_{i,i}^{(1)} = {{1\quad {or}\quad u_{i,i}^{(1)}} = {- 1}}},{and}} \end{matrix} \right.$

said second matrix U⁽²⁾ is equal to a diagonal matrix with for all j $\left\{ \begin{matrix} {{\forall{\left( {r,c} \right) \in \left\{ {{1\quad \ldots}\quad,m} \right\}^{2}}},{\left. {r \neq c}\Rightarrow u_{r,c}^{(2)} \right. = 0}} \\ {and} \\ {{\forall{j \in \left\{ {1,\ldots \quad,m} \right\}}},{u_{j,j}^{(2)}\quad {and}\quad N_{i,j}^{(n)}\quad {greatest}\quad {common}\quad {divider}\quad {is}\quad 1.}} \end{matrix} \right.$


10. The interleaver device according to claim 4, wherein said elementary term split function is configured to split a first facto into ⊕ with a tag of an image selected based on a comparison of a modulus of a subset of input values of said first factor to a constant threshold.
 11. The interleaver device according to claim 4, wherein said elementary term merge function is configured to merge two factors and into a merged factor , said two factors and selected such in accordance with a tag of an image tag corresponding to said two factorts ⊕, selected by an inverse bijection function based on a comparison of a modulus of a subset of input values of a first factor of said merged factor to a constant threshold.
 12. A method for interleaving a data set, comprising steps of: deriving a subset of bijective elementary functions (φ_(n)) from a predetermined set of bijective elementary functions (φ_(n)); compounding said subset of bijective elementary functions (φ_(n)) so as to produce a set of compounded bijective elementary functions; and interleaving said set of compounded bijective elementary functions in accordance with a predetermined interleaver definition (I⁻¹). 